home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk.zip / CAST.C < prev    next >
C/C++ Source or Header  |  1991-04-07  |  7KB  |  355 lines
  1.  
  2. /********************************************
  3. cast.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the Awk programming language as defined in
  8. Aho, Kernighan and Weinberger, The AWK Programming Language,
  9. Addison-Wesley, 1988.
  10.  
  11. See the accompaning file, LIMITATIONS, for restrictions
  12. regarding modification and redistribution of this
  13. program in source or binary form.
  14. ********************************************/
  15.  
  16.  
  17. /*   $Log:    cast.c,v $
  18.  * Revision 2.1  91/04/08  08:22:44  brennan
  19.  * VERSION 0.97
  20.  * 
  21. */
  22.  
  23.  
  24. /*  cast.c  */
  25.  
  26. #include "mawk.h"
  27. #include "field.h"
  28. #include "memory.h"
  29. #include "scan.h"
  30. #include "repl.h"
  31. #include <string.h>
  32.  
  33. int pow2[NUM_CELL_TYPES] = {1,2,4,8,16,32,64,128,256,512} ;
  34.  
  35. void cast1_to_d( cp )
  36.   register CELL *cp ;
  37. {
  38.   switch( cp->type )
  39.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  40.  
  41.     case C_DOUBLE :  return ;
  42.  
  43.     case C_MBSTRN :
  44.     case C_STRING :  
  45.           { register STRING *s = (STRING *) cp->ptr  ;
  46.  
  47. #if FPE_TRAPS  /* look for overflow error */
  48.             errno = 0 ;
  49.             cp->dval = strtod(s->str,(char **)0) ;
  50.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  51.                 rt_error("overflow converting %s to double", s) ;
  52. #else
  53.             cp->dval = strtod(s->str,(char **)0) ;
  54. #endif
  55.             free_STRING(s) ;
  56.           }
  57.             break ;
  58.  
  59.     case C_STRNUM :  
  60.       /* don't need to convert, but do need to free the STRING part */
  61.             free_STRING( string(cp) ) ;
  62.             break ;
  63.  
  64.  
  65.     default :
  66.             bozo("cast on bad type") ;
  67.   }
  68.   cp->type = C_DOUBLE ;
  69. }
  70.  
  71. void cast2_to_d( cp )
  72.   register CELL *cp ;
  73. { register STRING *s ;
  74.  
  75.   switch( cp->type )
  76.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  77.  
  78.     case C_DOUBLE :  goto two ;
  79.     case C_STRNUM :  
  80.             free_STRING( string(cp) ) ;
  81.             break ;
  82.  
  83.     case C_MBSTRN :
  84.     case C_STRING :  
  85.             s = (STRING *) cp->ptr ;
  86.  
  87. #if FPE_TRAPS  /* look for overflow error */
  88.             errno = 0 ;
  89.             cp->dval = strtod(s->str,(char **)0) ;
  90.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  91.                 rt_error("overflow converting %s to double", s) ;
  92. #else
  93.             cp->dval = strtod(s->str,(char **)0) ;
  94. #endif
  95.             free_STRING(s) ;
  96.             break ;
  97.  
  98.     default :
  99.             bozo("cast on bad type") ;
  100.   }
  101.   cp->type = C_DOUBLE ;
  102.  
  103. two:   cp++ ;
  104.   switch( cp->type )
  105.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  106.  
  107.     case C_DOUBLE :  return ;
  108.     case C_STRNUM :  
  109.             free_STRING( string(cp) ) ;
  110.             break ;
  111.  
  112.     case C_MBSTRN :
  113.     case C_STRING :  
  114.             s = (STRING *) cp->ptr ;
  115.  
  116. #if FPE_TRAPS  /* look for overflow error */
  117.             errno = 0 ;
  118.             cp->dval = strtod(s->str,(char **)0) ;
  119.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  120.                 rt_error("overflow converting %s to double", s) ;
  121. #else
  122.             cp->dval = strtod(s->str,(char **)0) ;
  123. #endif
  124.             free_STRING(s) ;
  125.             break ;
  126.  
  127.     default :
  128.             bozo("cast on bad type") ;
  129.   }
  130.   cp->type = C_DOUBLE ;
  131. }
  132.  
  133. void cast1_to_s( cp )
  134.   register CELL *cp ;
  135. { 
  136.   switch( cp->type )
  137.   { case C_NOINIT :  
  138.         null_str.ref_cnt++ ;
  139.         cp->ptr = (PTR) &null_str ;
  140.         break ;
  141.  
  142.     case C_DOUBLE  :
  143.         (void) sprintf(temp_buff.string_buff ,
  144.             string(field+OFMT)->str, cp->dval) ;
  145.  
  146.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  147.         break ;
  148.  
  149.     case C_STRING :  return ;
  150.  
  151.     case C_MBSTRN :
  152.     case C_STRNUM :  break ;
  153.  
  154.     default :  bozo("bad type on cast") ;
  155.   }
  156.   cp->type = C_STRING ;
  157. }
  158.  
  159. void cast2_to_s( cp )
  160.   register CELL *cp ;
  161. { 
  162.  
  163.   switch( cp->type )
  164.   { case C_NOINIT : 
  165.         null_str.ref_cnt++ ;
  166.         cp->ptr = (PTR) &null_str ;
  167.         break ;
  168.  
  169.     case C_DOUBLE  :
  170.         (void) sprintf(temp_buff.string_buff,
  171.             string(field+OFMT)->str, cp->dval ) ;
  172.  
  173.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  174.         break ;
  175.  
  176.     case C_STRING :  goto two ;
  177.  
  178.     case C_MBSTRN :
  179.     case C_STRNUM :  break ;
  180.  
  181.     default :  bozo("bad type on cast") ;
  182.   }
  183.   cp->type = C_STRING ;
  184.  
  185. two:
  186.   cp++ ;
  187.  
  188.   switch( cp->type )
  189.   { case C_NOINIT :  
  190.         null_str.ref_cnt++ ; 
  191.         cp->ptr = (PTR) &null_str ;
  192.         break ;
  193.  
  194.     case C_DOUBLE  :
  195.         (void) sprintf(temp_buff.string_buff,
  196.             string(field+OFMT)->str, cp->dval) ;
  197.  
  198.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  199.         break ;
  200.  
  201.     case C_STRING :  return ;
  202.  
  203.     case C_MBSTRN :
  204.     case C_STRNUM :  break ;
  205.  
  206.     default :  bozo("bad type on cast") ;
  207.   }
  208.   cp->type = C_STRING ;
  209. }
  210.  
  211. void  cast_to_RE( cp )
  212.   register CELL *cp ;
  213. { register PTR p ;
  214.  
  215.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  216.  
  217.   p = re_compile( string(cp) ) ;
  218.   free_STRING( string(cp) ) ;
  219.   cp->type = C_RE ;
  220.   cp->ptr = p ;
  221.  
  222. }
  223.  
  224. void  cast_for_split(cp)
  225.   register CELL *cp ;
  226. {
  227.   static char meta[] = "^$.*+?|[]()" ;
  228.   static char xbuff[] = "\\X" ;
  229.   int c ;
  230.   unsigned len ;
  231.     
  232.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  233.  
  234.   if ( (len = string(cp)->len) == 1 )
  235.   {
  236.         if ( (c = string(cp)->str[0]) == ' ' )
  237.         { free_STRING(string(cp)) ;
  238.           cp->type = C_SPACE ; 
  239.           return ; 
  240.         }
  241.         else
  242.         if ( strchr(meta, c) )
  243.         { xbuff[1] = c ;
  244.           free_STRING(string(cp)) ;
  245.           cp->ptr = (PTR) new_STRING(xbuff) ;
  246.         }
  247.   }
  248.   else
  249.   if ( len == 0 ) 
  250.   { free_STRING(string(cp)) ;
  251.     cp->type = C_SNULL ; 
  252.     return ; 
  253.   }
  254.  
  255.   cast_to_RE(cp) ;
  256. }
  257.  
  258. /* input: cp-> a CELL of type C_MBSTRN (maybe strnum)
  259.    test it -- casting it to the appropriate type
  260.    which is C_STRING or C_STRNUM
  261. */
  262.  
  263. void check_strnum( cp )
  264.   CELL *cp ;
  265. { char *test ;
  266.   register unsigned char *s , *q ;
  267.  
  268.   cp->type = C_STRING ; /* assume not C_STRNUM */
  269.   s = (unsigned char *) string(cp)->str ;
  270.   q = s + string(cp)->len ;
  271.   while ( scan_code[*s] == SC_SPACE )  s++ ;
  272.   if ( s == q )  return ;
  273.  
  274.   while ( scan_code[ q[-1] ] == SC_SPACE )  q-- ;
  275.   if ( scan_code[ q[-1] ] != SC_DIGIT &&
  276.        q[-1] != '.' )   return ;
  277.  
  278.   switch ( scan_code[*s] )
  279.   {
  280.     case SC_DIGIT :
  281.     case SC_PLUS  :
  282.     case SC_MINUS :
  283.     case SC_DOT   :
  284.  
  285. #if FPE_TRAPS
  286.              errno = 0 ;
  287.              cp->dval  = strtod((char *)s, &test) ;
  288.              if ( errno && cp->dval != 0.0 )
  289.                 rt_error(
  290.                 "overflow converting %s to double" , s) ;
  291. #else
  292.              cp->dval = strtod(s, &test) ;
  293. #endif
  294.  
  295.              if ((char *) q == test )  cp->type = C_STRNUM ;
  296.   }
  297. }
  298.  
  299. /* cast a CELL to a replacement cell */
  300.  
  301. void cast_to_REPL( cp )
  302.   register CELL *cp ;
  303. { register STRING *sval ;
  304.  
  305.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  306.   sval = (STRING *) cp->ptr ;
  307.  
  308.   (void) cellcpy(cp, repl_compile(sval)) ;
  309.   free_STRING(sval) ;
  310. }
  311.  
  312.  
  313. #if   NO_STRTOD
  314.  
  315. static char d_str[] =
  316. "^[ \t]*[-+]?([0-9]+\\.?|\\.[0-9])[0-9]*([eE][-+]?[0-9]+)?" ;
  317.  
  318. static PTR d_ptr ;
  319.  
  320. void strtod_init()
  321. { STRING *sval = new_STRING(d_str) ;
  322.  
  323.   d_ptr = re_compile(sval) ;
  324.   free_STRING(sval) ;
  325. }
  326.  
  327. double strtod( s, endptr)
  328.   char *s , **endptr ;
  329. { double atof() ;
  330.  
  331.   if ( endptr )
  332.   { unsigned len ;
  333.  
  334.     (void) REmatch(s, d_ptr, &len) ;
  335.     *endptr = s + len ;
  336.   }
  337.   return  atof(s) ;
  338. }
  339. #endif  /* NO_STRTOD */
  340.  
  341. #if   NO_FMOD
  342.  
  343. double  fmod(x, y)
  344.   double x, y ;
  345. { double modf() ;
  346.   double ipart ;
  347.  
  348.   return modf(x/y, &ipart) * y ;
  349. }
  350.  
  351. #endif  /* NO_FMOD */
  352.  
  353.  
  354.  
  355.